// /**
//  * 高性能固定更新管理器 - 使用示例
//  * 
//  * 演示三种不同性能级别的实现方案
//  * 
//  * @author AI Assistant
//  * @date 2025-11-26
//  */

// import { _decorator, Component, Label, Node, Vec3 } from 'cc';
// import { ecs } from '../../core/ecs/ECS';
// import { 
//     FunctionBasedFixedUpdateManager,
//     InlineFixedUpdateManager,
//     CompiledFixedUpdateManager,
//     createFunctionBasedFixedUpdate,
//     createInlineFixedUpdate,
//     createCompiledFixedUpdate,
//     ILogicSystemSet,
// } from './HighPerformanceFixedUpdateManager';
// import { InterpolatedTransform } from './component/InterpolatedTransform';
// import { ViewComponent } from './component/ViewComponent';

// const { ccclass, property } = _decorator;

// // ============================================================================
// // 示例 1: 函数式方案
// // ============================================================================

// /**
//  * 函数式固定更新示例
//  */
// @ccclass('FunctionBasedFixedUpdateExample')
// export class FunctionBasedFixedUpdateExample extends Component {
//     @property(Node)
//     container: Node = null!;
    
//     @property(Label)
//     statsLabel: Label = null!;
    
//     private fixedUpdate: FunctionBasedFixedUpdateManager;
//     private entities: ecs.Entity[] = [];
    
//     onLoad() {
//         this.fixedUpdate = createFunctionBasedFixedUpdate();
        
//         // 创建测试实体
//         this.createTestEntities(100);
        
//         // ⭐ 注册逻辑更新函数（直接函数调用，性能最优）
//         this.fixedUpdate.registerLogicUpdate((dt) => {
//             this.updateMovement(dt);
//         });
        
//         this.fixedUpdate.registerLogicUpdate((dt) => {
//             this.updatePhysics(dt);
//         });
//     }
    
//     update(deltaTime: number) {
//         // 调用固定更新
//         this.fixedUpdate.update(deltaTime);
        
//         // 插值渲染
//         this.interpolatedRender();
        
//         // 更新统计
//         this.updateStats();
//     }
    
//     private createTestEntities(count: number) {
//         for (let i = 0; i < count; i++) {
//             const entity = ecs.getEntity(ecs.Entity);
//             const transform = entity.add(InterpolatedTransform);
            
//             // 初始化位置
//             const angle = (i / count) * Math.PI * 2;
//             transform.setPosition(
//                 Math.cos(angle) * 100,
//                 Math.sin(angle) * 100,
//                 0
//             );
//             transform.syncPreviousFrame();
            
//             this.entities.push(entity);
//         }
//     }
    
//     private updateMovement(dt: number) {
//         // 移动逻辑
//         for (const entity of this.entities) {
//             const transform = entity.get(InterpolatedTransform);
//             if (transform) {
//                 const speed = 50;
//                 transform.move(
//                     Math.sin(Date.now() * 0.001) * speed * dt,
//                     Math.cos(Date.now() * 0.001) * speed * dt,
//                     0
//                 );
//             }
//         }
//     }
    
//     private updatePhysics(dt: number) {
//         // 物理逻辑（简化）
//         // ...
//     }
    
//     private interpolatedRender() {
//         const alpha = this.fixedUpdate.getInterpolationAlpha();
        
//         for (const entity of this.entities) {
//             const transform = entity.get(InterpolatedTransform);
//             if (transform) {
//                 const pos = transform.getInterpolatedPosition(alpha);
//                 // 更新视图（如果有）
//             }
//         }
//     }
    
//     private updateStats() {
//         if (!this.statsLabel) return;
        
//         const stats = this.fixedUpdate.getStatistics();
//         this.statsLabel.string = 
//             `函数式方案\n` +
//             `总更新次数: ${stats.totalFixedUpdates}\n` +
//             `平均耗时: ${stats.averageLogicTime.toFixed(2)}ms\n` +
//             `逻辑帧率: ${stats.currentFPS} FPS\n` +
//             `注册函数: ${stats.registeredFunctions}`;
//     }
// }

// // ============================================================================
// // 示例 2: 内联执行方案
// // ============================================================================

// /**
//  * 移动系统
//  */
// @ecs.register('Movement')
// class MovementSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter() {
//         return ecs.allOf(InterpolatedTransform);
//     }
    
//     update(entity: ecs.Entity) {
//         const transform = entity.get(InterpolatedTransform)!;
//         const speed = 50;
        
//         transform.move(
//             Math.sin(Date.now() * 0.001) * speed * this.dt,
//             Math.cos(Date.now() * 0.001) * speed * this.dt,
//             0
//         );
//     }
// }

// /**
//  * 物理系统
//  */
// @ecs.register('Physics')
// class PhysicsSystem extends ecs.ComblockSystem implements ecs.ISystemUpdate {
//     filter() {
//         return ecs.allOf(InterpolatedTransform);
//     }
    
//     update(entity: ecs.Entity) {
//         // 物理逻辑
//     }
// }

// /**
//  * 内联执行示例
//  */
// @ccclass('InlineFixedUpdateExample')
// export class InlineFixedUpdateExample extends Component {
//     @property(Node)
//     container: Node = null!;
    
//     @property(Label)
//     statsLabel: Label = null!;
    
//     private fixedUpdate: InlineFixedUpdateManager;
//     private entities: ecs.Entity[] = [];
    
//     onLoad() {
//         this.fixedUpdate = createInlineFixedUpdate();
        
//         // 创建测试实体
//         this.createTestEntities(100);
        
//         // ⭐ 注册 ECS 系统（使用内联执行，平衡性能和架构）
//         this.fixedUpdate.registerLogicSystem(new MovementSystem());
//         this.fixedUpdate.registerLogicSystem(new PhysicsSystem());
//     }
    
//     update(deltaTime: number) {
//         this.fixedUpdate.update(deltaTime);
//         this.interpolatedRender();
//     }
    
//     private createTestEntities(count: number) {
//         for (let i = 0; i < count; i++) {
//             const entity = ecs.getEntity(ecs.Entity);
//             const transform = entity.add(InterpolatedTransform);
            
//             const angle = (i / count) * Math.PI * 2;
//             transform.setPosition(
//                 Math.cos(angle) * 100,
//                 Math.sin(angle) * 100,
//                 0
//             );
//             transform.syncPreviousFrame();
            
//             this.entities.push(entity);
//         }
//     }
    
//     private interpolatedRender() {
//         const alpha = this.fixedUpdate.getInterpolationAlpha();
        
//         for (const entity of this.entities) {
//             const transform = entity.get(InterpolatedTransform);
//             if (transform) {
//                 const pos = transform.getInterpolatedPosition(alpha);
//                 // 更新视图
//             }
//         }
//     }
// }

// // ============================================================================
// // 示例 3: 编译时优化方案（极致性能）⭐⭐⭐⭐⭐
// // ============================================================================

// /**
//  * 具体的移动逻辑系统
//  */
// class ConcreteMovementSystem {
//     private entities: ecs.Entity[] = [];
    
//     addEntity(entity: ecs.Entity) {
//         this.entities.push(entity);
//     }
    
//     execute(dt: number) {
//         const speed = 50;
//         const time = Date.now() * 0.001;
        
//         for (const entity of this.entities) {
//             const transform = entity.get(InterpolatedTransform);
//             if (transform) {
//                 transform.move(
//                     Math.sin(time) * speed * dt,
//                     Math.cos(time) * speed * dt,
//                     0
//                 );
//             }
//         }
//     }
// }

// /**
//  * 具体的物理系统
//  */
// class ConcretePhysicsSystem {
//     private entities: ecs.Entity[] = [];
    
//     addEntity(entity: ecs.Entity) {
//         this.entities.push(entity);
//     }
    
//     execute(dt: number) {
//         // 物理逻辑
//     }
// }

// /**
//  * 具体的战斗系统
//  */
// class ConcreteCombatSystem {
//     private entities: ecs.Entity[] = [];
    
//     addEntity(entity: ecs.Entity) {
//         this.entities.push(entity);
//     }
    
//     execute(dt: number) {
//         // 战斗逻辑
//     }
// }

// /**
//  * 定义系统集合（编译时类型检查）
//  */
// interface GameLogicSystems extends ILogicSystemSet {
//     movement: ConcreteMovementSystem;
//     physics: ConcretePhysicsSystem;
//     combat: ConcreteCombatSystem;
// }

// /**
//  * 编译时优化示例（极致性能）
//  */
// @ccclass('CompiledFixedUpdateExample')
// export class CompiledFixedUpdateExample extends Component {
//     @property(Node)
//     container: Node = null!;
    
//     @property(Label)
//     statsLabel: Label = null!;
    
//     // ⭐ 使用泛型，编译时确定类型
//     private fixedUpdate: CompiledFixedUpdateManager<GameLogicSystems>;
//     private entities: ecs.Entity[] = [];
    
//     // 系统实例
//     private movementSystem: ConcreteMovementSystem;
//     private physicsSystem: ConcretePhysicsSystem;
//     private combatSystem: ConcreteCombatSystem;
    
//     onLoad() {
//         // 创建系统实例
//         this.movementSystem = new ConcreteMovementSystem();
//         this.physicsSystem = new ConcretePhysicsSystem();
//         this.combatSystem = new ConcreteCombatSystem();
        
//         // ⭐ 创建编译时优化的管理器（类型安全）
//         this.fixedUpdate = createCompiledFixedUpdate<GameLogicSystems>({
//             movement: this.movementSystem,
//             physics: this.physicsSystem,
//             combat: this.combatSystem,
//         });
        
//         // 创建测试实体
//         this.createTestEntities(100);
//     }
    
//     update(deltaTime: number) {
//         // ⭐ 调用更新（编译器会优化这个调用链）
//         this.fixedUpdate.update(deltaTime);
        
//         this.interpolatedRender();
//         this.updateStats();
//     }
    
//     private createTestEntities(count: number) {
//         for (let i = 0; i < count; i++) {
//             const entity = ecs.getEntity(ecs.Entity);
//             const transform = entity.add(InterpolatedTransform);
            
//             const angle = (i / count) * Math.PI * 2;
//             transform.setPosition(
//                 Math.cos(angle) * 100,
//                 Math.sin(angle) * 100,
//                 0
//             );
//             transform.syncPreviousFrame();
            
//             // 添加到系统
//             this.movementSystem.addEntity(entity);
//             this.physicsSystem.addEntity(entity);
//             this.combatSystem.addEntity(entity);
            
//             this.entities.push(entity);
//         }
//     }
    
//     private interpolatedRender() {
//         const alpha = this.fixedUpdate.getInterpolationAlpha();
        
//         for (const entity of this.entities) {
//             const transform = entity.get(InterpolatedTransform);
//             if (transform) {
//                 const pos = transform.getInterpolatedPosition(alpha);
//                 // 更新视图
//             }
//         }
//     }
    
//     private updateStats() {
//         if (!this.statsLabel) return;
        
//         // ⭐ 类型安全的系统访问
//         const movement = this.fixedUpdate.getSystem('movement');
//         const physics = this.fixedUpdate.getSystem('physics');
        
//         this.statsLabel.string = 
//             `编译时优化方案\n` +
//             `插值因子: ${this.fixedUpdate.getInterpolationAlpha().toFixed(2)}\n` +
//             `实体数量: ${this.entities.length}`;
//     }
// }

// // ============================================================================
// // 性能对比测试
// // ============================================================================

// /**
//  * 性能对比组件
//  */
// @ccclass('FixedUpdatePerformanceComparison')
// export class FixedUpdatePerformanceComparison extends Component {
//     @property(Label)
//     resultsLabel: Label = null!;
    
//     private results: {
//         name: string;
//         averageTime: number;
//         minTime: number;
//         maxTime: number;
//     }[] = [];
    
//     start() {
//         console.log('开始性能测试...');
        
//         // 创建测试实体
//         const entities = this.createTestEntities(1000);
        
//         // 测试各方案
//         this.testFunctionBased(entities);
//         this.testInline(entities);
//         this.testCompiled(entities);
        
//         // 显示结果
//         this.displayResults();
//     }
    
//     private createTestEntities(count: number): ecs.Entity[] {
//         const entities: ecs.Entity[] = [];
        
//         for (let i = 0; i < count; i++) {
//             const entity = ecs.getEntity(ecs.Entity);
//             const transform = entity.add(InterpolatedTransform);
//             transform.setPosition(0, 0, 0);
//             transform.syncPreviousFrame();
//             entities.push(entity);
//         }
        
//         return entities;
//     }
    
//     private testFunctionBased(entities: ecs.Entity[]) {
//         const manager = createFunctionBasedFixedUpdate();
//         manager.clear();
        
//         manager.registerLogicUpdate((dt) => {
//             for (const entity of entities) {
//                 const transform = entity.get(InterpolatedTransform);
//                 if (transform) {
//                     transform.move(1, 1, 0);
//                 }
//             }
//         });
        
//         const times = this.runBenchmark(() => manager.update(0.016), 100);
//         this.results.push({
//             name: '函数式方案',
//             ...this.calculateStats(times)
//         });
//     }
    
//     private testInline(entities: ecs.Entity[]) {
//         // 类似测试...
//     }
    
//     private testCompiled(entities: ecs.Entity[]) {
//         // 类似测试...
//     }
    
//     private runBenchmark(fn: () => void, iterations: number): number[] {
//         const times: number[] = [];
        
//         for (let i = 0; i < iterations; i++) {
//             const start = performance.now();
//             fn();
//             const end = performance.now();
//             times.push(end - start);
//         }
        
//         return times;
//     }
    
//     private calculateStats(times: number[]) {
//         const sum = times.reduce((a, b) => a + b, 0);
//         return {
//             averageTime: sum / times.length,
//             minTime: Math.min(...times),
//             maxTime: Math.max(...times),
//         };
//     }
    
//     private displayResults() {
//         if (!this.resultsLabel) return;
        
//         let text = '性能对比结果（1000 个实体）\n\n';
        
//         for (const result of this.results) {
//             text += `${result.name}:\n`;
//             text += `  平均: ${result.averageTime.toFixed(3)}ms\n`;
//             text += `  最小: ${result.minTime.toFixed(3)}ms\n`;
//             text += `  最大: ${result.maxTime.toFixed(3)}ms\n\n`;
//         }
        
//         this.resultsLabel.string = text;
//         console.log(text);
//     }
// }

